package com.ssm.sport.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ssm.sport.dto.ResultDTO;
import com.ssm.sport.entity.Product;
import com.ssm.sport.entity.Category;
import com.ssm.sport.entity.Order;
import com.ssm.sport.entity.User;
import com.ssm.sport.entity.Banner;
import com.ssm.sport.service.ProductService;
import com.ssm.sport.service.CategoryService;
import com.ssm.sport.service.OrderService;
import com.ssm.sport.service.UserService;
import com.ssm.sport.service.BannerService;
import com.ssm.sport.vo.OrderVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.util.DigestUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.text.SimpleDateFormat;

/**
 * 后台管理控制器
 */
@Controller
@RequestMapping("/admin")
public class AdminController {

    @Value("${upload.base.dir}")
    private String uploadBaseDir;
    
    @Autowired
    private ProductService productService;
    
    @Autowired
    private CategoryService categoryService;
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private BannerService bannerService;
    
    /**
     * 后台登录页面
     */
    @GetMapping("/login")
    public String loginPage() {
        return "admin/login";
    }
    
    /**
     * 后台登录处理
     */
    @PostMapping("/login")
    @ResponseBody
    public ResultDTO<?> login(String username, String password, HttpSession session) {
        if (username == null || password == null) {
            return ResultDTO.failure("用户名和密码不能为空");
        }
        
        // 这里简化处理，实际应该从数据库中查询管理员账号
        if ("admin".equals(username) && "admin123".equals(password)) {
            session.setAttribute("adminUser", username);
            return ResultDTO.success("登录成功");
        }
        
        return ResultDTO.failure("用户名或密码错误");
    }
    
    /**
     * 后台登出
     */
    @GetMapping("/logout")
    public String logout(HttpSession session) {
        session.removeAttribute("adminUser");
        return "redirect:/admin/login";
    }
    
    /**
     * 后台首页
     */
    @GetMapping({"", "/", "/index"})
    public String index(HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/login";
        }
        return "admin/index";
    }
    
    /**
     * 获取仪表盘统计数据
     * @return 统计数据
     */
    @GetMapping("/dashboard/stats")
    @ResponseBody
    public ResultDTO getDashboardStats() {
        Map<String, Object> stats = new HashMap<>();
        
        // 获取产品总数
        long totalProducts = productService.count();
        stats.put("totalProducts", totalProducts);
        System.out.println("总商品数: " + totalProducts);
        
        // 获取分类总数
        long totalCategories = categoryService.count();
        stats.put("totalCategories", totalCategories);
        System.out.println("总分类数: " + totalCategories);
        
        // 获取用户总数
        long totalUsers = userService.count();
        stats.put("totalUsers", totalUsers);
        System.out.println("用户总数: " + totalUsers);
        
        // 获取库存总数
        Long totalStock = productService.getTotalStock();
        stats.put("totalStock", totalStock);
        System.out.println("库存总数: " + totalStock);
        
        // 获取订单总数
        stats.put("totalOrders", orderService.count());
        
        // 获取今日订单数
        stats.put("todayOrders", orderService.getTodayOrderCount());
        
        // 获取待处理订单数
        stats.put("pendingOrders", orderService.getPendingOrderCount());
        
        // 获取总销售额
        stats.put("totalSales", orderService.getTotalSales());
        
        // 获取最近7天的销售数据
        stats.put("dailySales", getDailySalesData());
        
        System.out.println("Dashboard stats结果: " + stats);
        
        return ResultDTO.success(stats);
    }
    
    /**
     * 获取最近7天的每日销售数据
     * @return 销售数据列表
     */
    private List<Map<String, Object>> getDailySalesData() {
        List<Map<String, Object>> result = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("MM/dd");
        Calendar calendar = Calendar.getInstance();
        
        // 生成最近7天的数据
        for (int i = 6; i >= 0; i--) {
            calendar.setTime(new Date());
            calendar.add(Calendar.DAY_OF_MONTH, -i);
            Date date = calendar.getTime();
            
            Map<String, Object> dayData = new HashMap<>();
            dayData.put("date", sdf.format(date));
            
            // 这里应该从订单服务中获取当天的销售额
            // 为了简化实现，这里使用模拟数据
            double amount = 0;
            if (orderService != null) {
                // 获取实际数据，如果有实现的话
                // amount = orderService.getDailySales(date);
                
                // 模拟数据，实际项目中应该替换为真实查询
                amount = 500 + Math.random() * 2000;
            }
            
            dayData.put("amount", (int)amount);
            result.add(dayData);
        }
        
        return result;
    }
    
    /**
     * 商品管理页面
     */
    @GetMapping("/products")
    public String productsPage(HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/login";
        }
        
        List<Category> categories = categoryService.list();
        model.addAttribute("categories", categories);
        
        return "admin/product_list";
    }
    
    /**
     * 获取商品列表数据
     */
    @GetMapping("/products/list")
    @ResponseBody
    public ResultDTO<?> productList(Integer pageNum, Integer pageSize) {
        if (pageNum == null || pageNum <= 0) {
            pageNum = 1;
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }
        
        Page<Product> page = new Page<>(pageNum, pageSize);
        IPage<Product> productPage = productService.page(page);
        
        return ResultDTO.success(productPage);
    }
    
    /**
     * 添加商品
     */
    @PostMapping("/products/add")
    @ResponseBody
    public ResultDTO<?> addProduct(@RequestBody Product product) {
        if (product.getName() == null || product.getPrice() == null) {
            return ResultDTO.failure("商品名称和价格不能为空");
        }
        
        // 设置默认值
        if (product.getStatus() == null) {
            product.setStatus(1); // 默认上架
        }
        
        boolean success = productService.save(product);
        return success ? ResultDTO.success("添加商品成功") : ResultDTO.failure("添加商品失败");
    }
    
    /**
     * 更新商品
     */
    @PostMapping("/products/update")
    @ResponseBody
    public ResultDTO<?> updateProduct(@RequestBody Product product) {
        if (product.getId() == null) {
            return ResultDTO.failure("商品ID不能为空");
        }
        
        boolean success = productService.updateById(product);
        return success ? ResultDTO.success("更新商品成功") : ResultDTO.failure("更新商品失败");
    }
    
    /**
     * 更新商品状态
     */
    @PostMapping("/products/status/{id}/{status}")
    @ResponseBody
    public ResultDTO<?> updateProductStatus(@PathVariable Integer id, @PathVariable Integer status) {
        if (id == null || id <= 0) {
            return ResultDTO.failure("商品ID不合法");
        }
        if (status == null || (status != 0 && status != 1)) {
            return ResultDTO.failure("状态值不合法");
        }
        
        Product product = new Product();
        product.setId(id);
        product.setStatus(status);
        
        boolean success = productService.updateById(product);
        return success ? ResultDTO.success("更新商品状态成功") : ResultDTO.failure("更新商品状态失败");
    }
    
    /**
     * 删除商品
     */
    @PostMapping("/products/delete/{id}")
    @ResponseBody
    public ResultDTO<?> deleteProduct(@PathVariable Integer id) {
        if (id == null || id <= 0) {
            return ResultDTO.failure("商品ID不合法");
        }
        
        boolean success = productService.removeById(id);
        return success ? ResultDTO.success("删除商品成功") : ResultDTO.failure("删除商品失败");
    }
    
    /**
     * 上传图片
     */
    @PostMapping("/upload")
    @ResponseBody
    public ResultDTO<?> uploadImage(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
        if (file.isEmpty()) {
            return ResultDTO.failure("上传的文件不能为空");
        }
        
        try {
            // 1. 判断上传路径是否可用，不可用则使用应用部署路径
            String sourceUploadDir = uploadBaseDir;
            File sourceDir = new File(sourceUploadDir);
            
            // 如果配置的目录不存在或不可写，则使用应用部署路径作为备选
            if (!sourceDir.exists() || !sourceDir.canWrite()) {
                // 获取应用部署的实际路径
                String webappRootPath = request.getServletContext().getRealPath("/");
                sourceUploadDir = webappRootPath + "static/uploads/";
                sourceDir = new File(sourceUploadDir);
            }
            
            if (!sourceDir.exists()) {
                sourceDir.mkdirs();
            }
            
            // 2. 同时保存到部署目录（当前运行的应用）
            String deployedUploadDir = request.getServletContext().getRealPath("/static/uploads/");
            File deployedDir = new File(deployedUploadDir);
            if (!deployedDir.exists()) {
                deployedDir.mkdirs();
            }
            
            // 生成新的文件名
            String originalFilename = file.getOriginalFilename();
            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
            String newFilename = UUID.randomUUID().toString() + extension;
            
            // 保存文件到两个目录
            // 1. 保存到源代码目录
            File sourceDest = new File(sourceDir, newFilename);
            file.transferTo(sourceDest);
            
            // 2. 保存到部署目录
            File deployedDest = new File(deployedDir, newFilename);
            // 如果两个路径不同，则复制文件
            if (!sourceDest.getAbsolutePath().equals(deployedDest.getAbsolutePath())) {
                java.nio.file.Files.copy(sourceDest.toPath(), deployedDest.toPath());
            }
            
            // 返回完整的访问URL，包含上下文路径
            String contextPath = request.getContextPath();
            String imageUrl = "/static/uploads/" + newFilename;
            return ResultDTO.success(imageUrl, "上传成功");
        } catch (IOException e) {
            e.printStackTrace();
            return ResultDTO.failure("上传失败: " + e.getMessage());
        }
    }
    
    /**
     * 分类管理页面
     */
    @GetMapping("/categories")
    public String categoriesPage(HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/login";
        }
        return "admin/category_list";
    }
    
    /**
     * 获取分类列表
     */
    @GetMapping("/categories/list")
    @ResponseBody
    public ResultDTO<?> categoryList() {
        List<Category> categories = categoryService.list();
        return ResultDTO.success(categories);
    }
    
    /**
     * 添加分类
     */
    @PostMapping("/categories/add")
    @ResponseBody
    public ResultDTO<?> addCategory(@RequestBody Category category) {
        if (category.getName() == null) {
            return ResultDTO.failure("分类名称不能为空");
        }
        
        boolean success = categoryService.save(category);
        return success ? ResultDTO.success("添加分类成功") : ResultDTO.failure("添加分类失败");
    }
    
    /**
     * 更新分类
     */
    @PostMapping("/categories/update")
    @ResponseBody
    public ResultDTO<?> updateCategory(@RequestBody Category category) {
        if (category.getId() == null) {
            return ResultDTO.failure("分类ID不能为空");
        }
        
        boolean success = categoryService.updateById(category);
        return success ? ResultDTO.success("更新分类成功") : ResultDTO.failure("更新分类失败");
    }
    
    /**
     * 删除分类
     */
    @PostMapping("/categories/delete/{id}")
    @ResponseBody
    public ResultDTO<?> deleteCategory(@PathVariable Integer id) {
        if (id == null || id <= 0) {
            return ResultDTO.failure("分类ID不合法");
        }
        
        // 检查是否有商品使用此分类
        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("category_id", id);
        long count = productService.count(queryWrapper);
        if (count > 0) {
            return ResultDTO.failure("该分类下还有商品，无法删除");
        }
        
        boolean success = categoryService.removeById(id);
        return success ? ResultDTO.success("删除分类成功") : ResultDTO.failure("删除分类失败");
    }
    
    /**
     * 用户管理页面
     */
    @GetMapping("/users")
    public String usersPage(HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/login";
        }
        return "admin/user_list";
    }
    
    /**
     * 获取用户列表
     */
    @GetMapping("/users/list")
    @ResponseBody
    public ResultDTO<?> userList(Integer pageNum, Integer pageSize, String username, Integer status) {
        try {
            if (pageNum == null || pageNum <= 0) {
                pageNum = 1;
            }
            if (pageSize == null || pageSize <= 0) {
                pageSize = 10;
            }
            
            // 创建查询条件
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("role", 0); // 只查询角色为普通用户的记录
            
            // 如果提供了用户名，添加模糊查询条件
            if (username != null && !username.trim().isEmpty()) {
                queryWrapper.like("username", username.trim());
            }
            
            // 如果提供了状态，添加精确匹配条件
            if (status != null) {
                queryWrapper.eq("status", status);
            }
            
            // 按注册时间降序排序
            queryWrapper.orderByDesc("create_time");
            
            Page<User> page = new Page<>(pageNum, pageSize);
            IPage<User> userPage = userService.page(page, queryWrapper);
            
            // 处理结果中的敏感信息
            for (User user : userPage.getRecords()) {
                user.setPassword(null); // 移除密码信息
            }
            
            // 返回成功结果，携带用户分页数据
            return ResultDTO.success(userPage);
        } catch (Exception e) {
            // 记录异常并返回友好的错误信息
            e.printStackTrace(); // 在生产环境中应该使用日志框架记录
            return ResultDTO.failure("获取用户列表失败: " + e.getMessage());
        }
    }
    
    /**
     * 更新用户状态
     */
    @PostMapping("/users/status/{userId}/{status}")
    @ResponseBody
    public ResultDTO<?> updateUserStatus(@PathVariable Integer userId, @PathVariable Integer status) {
        if (userId == null || userId <= 0) {
            return ResultDTO.failure("用户ID不合法");
        }
        
        if (status == null || (status != 0 && status != 1)) {
            return ResultDTO.failure("状态值不合法");
        }
        
        User user = userService.getById(userId);
        if (user == null) {
            return ResultDTO.failure("用户不存在");
        }
        
        user.setStatus(status);
        boolean success = userService.updateById(user);
        
        return success ? 
            ResultDTO.success("更新用户状态成功") : 
            ResultDTO.failure("更新用户状态失败");
    }
    
    /**
     * 获取用户详情
     */
    @GetMapping("/users/detail/{userId}")
    @ResponseBody
    public ResultDTO<?> getUserDetail(@PathVariable Integer userId) {
        if (userId == null || userId <= 0) {
            return ResultDTO.failure("用户ID不合法");
        }
        
        User user = userService.getById(userId);
        if (user == null) {
            return ResultDTO.failure("用户不存在");
        }
        
        // 移除敏感信息
        user.setPassword(null);
        
        return ResultDTO.success(user);
    }
    
    /**
     * 添加用户
     */
    @PostMapping("/users/add")
    @ResponseBody
    public ResultDTO<?> addUser(@RequestBody User user) {
        // 基本验证
        if (user.getUsername() == null || user.getUsername().trim().isEmpty()) {
            return ResultDTO.failure("用户名不能为空");
        }
        
        if (user.getPassword() == null || user.getPassword().trim().isEmpty()) {
            return ResultDTO.failure("密码不能为空");
        }
        
        // 检查用户名是否已存在
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", user.getUsername().trim());
        if (userService.count(queryWrapper) > 0) {
            return ResultDTO.failure("用户名已存在");
        }
        
        // 设置默认值
        if (user.getStatus() == null) {
            user.setStatus(1); // 默认正常状态
        }
        user.setRole(0); // 普通用户
        
        // 密码加密（实际项目中应使用更安全的加密方式，如BCrypt）
        // 这里简单加密示例
        user.setPassword(DigestUtils.md5DigestAsHex(user.getPassword().getBytes()));
        
        boolean success = userService.save(user);
        return success ? ResultDTO.success("添加用户成功") : ResultDTO.failure("添加用户失败");
    }
    
    /**
     * 更新用户
     */
    @PostMapping("/users/update")
    @ResponseBody
    public ResultDTO<?> updateUser(@RequestBody User user) {
        if (user.getId() == null || user.getId() <= 0) {
            return ResultDTO.failure("用户ID不合法");
        }
        
        if (user.getUsername() == null || user.getUsername().trim().isEmpty()) {
            return ResultDTO.failure("用户名不能为空");
        }
        
        // 获取原始用户数据
        User existingUser = userService.getById(user.getId());
        if (existingUser == null) {
            return ResultDTO.failure("用户不存在");
        }
        
        // 检查用户名是否已被其他用户使用
        if (!existingUser.getUsername().equals(user.getUsername())) {
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("username", user.getUsername().trim())
                    .ne("id", user.getId());
            if (userService.count(queryWrapper) > 0) {
                return ResultDTO.failure("用户名已被使用");
            }
        }
        
        // 只更新允许的字段
        existingUser.setUsername(user.getUsername());
        if (user.getEmail() != null) {
            existingUser.setEmail(user.getEmail());
        }
        if (user.getPhone() != null) {
            existingUser.setPhone(user.getPhone());
        }
        existingUser.setStatus(user.getStatus());
        
        // 如果提供了新密码，则更新密码
        if (user.getPassword() != null && !user.getPassword().trim().isEmpty()) {
            existingUser.setPassword(DigestUtils.md5DigestAsHex(user.getPassword().getBytes()));
        }
        
        boolean success = userService.updateById(existingUser);
        return success ? ResultDTO.success("更新用户成功") : ResultDTO.failure("更新用户失败");
    }
    
    /**
     * 订单管理页面
     */
    @GetMapping("/orders")
    public String ordersPage(HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/login";
        }
        return "admin/order_list";
    }
    
    /**
     * 获取订单列表
     */
    @GetMapping("/orders/list")
    @ResponseBody
    public ResultDTO<?> orderList(Integer pageNum, Integer pageSize) {
        if (pageNum == null || pageNum <= 0) {
            pageNum = 1;
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }
        
        Page<OrderVO> orderPage = orderService.getAllOrderList(pageNum, pageSize);
        return ResultDTO.success(orderPage);
    }
    
    /**
     * 订单详情页面
     */
    @GetMapping("/orders/detail/{orderNo}")
    public String orderDetail(@PathVariable String orderNo, HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/orders";
        }
        
        // 直接获取订单详情，不需要先查询订单主表
        try {
            // 尝试获取订单详情
            OrderVO orderVO = orderService.getOrderDetail(null, orderNo);
            
            if (orderVO == null) {
                return "redirect:/admin/orders";
            }
            
            model.addAttribute("order", orderVO);
            
            return "admin/order_detail";
        } catch (Exception e) {
            // 如果发生异常，重定向到订单列表页
            return "redirect:/admin/orders";
        }
    }
    
    /**
     * 发货处理
     */
    @PostMapping("/orders/ship/{orderNo}")
    @ResponseBody
    public ResultDTO<?> shipOrder(@PathVariable String orderNo) {
        if (orderNo == null || orderNo.trim().isEmpty()) {
            return ResultDTO.failure("订单号不能为空");
        }
        
        boolean success = orderService.sendOrder(orderNo);
        return success ? ResultDTO.success("发货成功") : ResultDTO.failure("发货失败，可能订单不存在或状态不允许发货");
    }
    
    /**
     * Banner管理页面
     */
    @GetMapping("/banners")
    public String bannersPage(HttpSession session, Model model) {
        if (session.getAttribute("adminUser") == null) {
            return "redirect:/admin/login";
        }
        return "admin/banner_list";
    }
    
    /**
     * 获取Banner列表
     */
    @GetMapping("/banners/list")
    @ResponseBody
    public ResultDTO<?> bannerList(Integer pageNum, Integer pageSize) {
        if (pageNum == null || pageNum <= 0) {
            pageNum = 1;
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }
        
        Page<Banner> page = bannerService.list(pageNum, pageSize);
        return ResultDTO.success(page);
    }
    
    /**
     * 添加Banner
     */
    @PostMapping("/banners/add")
    @ResponseBody
    public ResultDTO<?> addBanner(@RequestBody Banner banner) {
        if (banner.getTitle() == null || banner.getImageUrl() == null) {
            return ResultDTO.failure("轮播图标题和图片URL不能为空");
        }
        
        boolean success = bannerService.add(banner);
        return success ? ResultDTO.success("添加轮播图成功") : ResultDTO.failure("添加轮播图失败");
    }
    
    /**
     * 更新Banner
     */
    @PostMapping("/banners/update")
    @ResponseBody
    public ResultDTO<?> updateBanner(@RequestBody Banner banner) {
        if (banner.getId() == null) {
            return ResultDTO.failure("轮播图ID不能为空");
        }
        
        boolean success = bannerService.update(banner);
        return success ? ResultDTO.success("更新轮播图成功") : ResultDTO.failure("更新轮播图失败");
    }
    
    /**
     * 删除Banner
     */
    @PostMapping("/banners/delete/{id}")
    @ResponseBody
    public ResultDTO<?> deleteBanner(@PathVariable Integer id) {
        if (id == null || id <= 0) {
            return ResultDTO.failure("轮播图ID不合法");
        }
        
        boolean success = bannerService.delete(id);
        return success ? ResultDTO.success("删除轮播图成功") : ResultDTO.failure("删除轮播图失败");
    }
    
    /**
     * 获取热门商品列表
     */
    @GetMapping("/products/hot")
    @ResponseBody
    public ResultDTO<?> getHotProducts() {
        try {
            // 获取销量前5的商品
            List<Product> hotProducts = productService.getHotProducts(5);
            
            // 返回成功结果
            return ResultDTO.success(hotProducts);
        } catch (Exception e) {
            // 记录异常并返回友好的错误信息
            e.printStackTrace();
            return ResultDTO.failure("获取热门商品失败: " + e.getMessage());
        }
    }
} 